{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt-get install -y xvfb python-opengl > /dev/null 2>&1\n",
    "    !pip install gym pyvirtualdisplay > /dev/null 2>&1\n",
    "    !pip install JSAnimation==0.1\n",
    "    !pip install pyglet==1.3.2\n",
    "    \n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 04. TD3\n",
    "\n",
    "[Fujimoto, Scott, Herke van Hoof, and David Meger. \"Addressing function approximation error in actor-critic methods.\" arXiv preprint arXiv:1802.09477 2018.](https://arxiv.org/pdf/1802.09477.pdf)\n",
    "\n",
    "In value-based reinforcement learning methods, function approximation errors are known to lead to overestimated value estimates and suboptimal policies. However, similar issues with actor-critic methods in continuous control domains have been largely left untouched (See paper for detailed description). To solve this problem, this paper proposes *a clipped Double Q-learning*. In addtion, this paper contains a number of components that address variance reduction.\n",
    "\n",
    "The author's modifications are applied to actor-critic method for continuous control, Deep Deterministic Policy Gradient algorithm ([DDPG](https://arxiv.org/pdf/1509.02971.pdf)), to form the *Twin Delayed Deep Deterministic policy gradient algorithm (TD3)*.\n",
    "\n",
    "### DDPG\n",
    "For learning in high-dimentional and continous action spaces, the authors of DDPG combine the actor-critic approach with insights from the success of DQN. Deep DPG(DDPG) is based on the deterministic policy gradient(DPG) algorithm ([Silver et al., 2014](http://proceedings.mlr.press/v32/silver14.pdf)). Please see *03.DDPG.ipynb* for detailed description of DDPG.\n",
    "\n",
    "### Double Q-learning\n",
    "In Double DQN ([Van Hasselt et al., 2016](https://arxiv.org/pdf/1509.06461.pdf)), the authors propose using the target network as one of the value estimates, and obtain a policy by greedy maximization of the current value network rather than the target network. In an actor-critic setting, an analogous update uses the current policy rather than the target policy in the learning target. However, with the slow-changing policy in actor-critic, the current and target networks were too similar to make an independent estimation, and offered little improvement. Instead, the original Double Q-learning formulation can be used, with a pair of actors $(\\pi_{\\phi_1}, \\pi_{\\phi_2})$ and critics $(Q_{\\theta_1}, Q_{\\theta_2})$, where $\\pi_{\\phi_1}$ is optimized with respect to $Q_{\\theta_1}$ and $\\pi_{\\phi_2}$ with respect to $Q_{\\theta_2}$:\n",
    "\n",
    "$$\n",
    "y_1 = r + \\gamma Q_{\\theta'_2} (s' , \\pi_{\\phi_1}(s')) \\\\\n",
    "y_2 = r + \\gamma Q_{\\theta'_1} (s' , \\pi_{\\phi_2}(s'))\n",
    "$$\n",
    "\n",
    "### A clipped Double Q-learning\n",
    "The critics are not entirely independent, due to the use of the opposite critic in the learning targets, as well as the same replay buffer. As a result, for some states we will have $Q_{\\theta'_2}(s, \\pi_{\\phi_1}) > Q_{\\theta'_1}(s, \\pi_{\\phi_1})$. This is problematic because $Q_{\\theta'_1}(s, \\pi_{\\phi_1})$ will generally overestimate the true value, and in certain areas of the state space the overestimation will be further exaggerated. To address this problem, the authors propose to take the minimum between the two estimates:\n",
    "\n",
    "$$\n",
    "y_1 = r + \\gamma \\underset{i=1,2}{\\min} Q_{\\theta'_i} (s' , \\pi_{\\phi_1}(s'))\n",
    "$$\n",
    "\n",
    "### Delayed Policy Updates\n",
    "If policy updates on high-error states cause different behavior, then the policy network should be updated at a lower frequency than the value network, to first minimize error before introducing a policy update. The authors propose delaying policy updates until the value error is as small as possible.\n",
    "\n",
    "### Target Policy Smoothing Regularization\n",
    "When updating the critic, a learning target using a deterministic policy is highly susceptible to in accuracies induced by function approximation error, increasing the variance of the target. This induced variance can be reduced through regularization. The authors propose that fitting the value of a small area around the target action\n",
    "\n",
    "$$\n",
    "y = r + E_\\epsilon [Q_{\\theta'}(s', \\pi_{\\phi '}(s') + \\epsilon],\n",
    "$$\n",
    "\n",
    "would have the benefit of smoothing the value estimate by bootstrapping off of similar state-action value estimates. In practice, this makes below:\n",
    "\n",
    "$$\n",
    "y = r + \\gamma Q_{\\theta '}(s', \\pi_{\\phi '}(s') + \\epsilon), \\\\\n",
    "\\epsilon \\sim \\text{clip} (\\mathcal(N)(0, \\sigma), -c, c),\n",
    "$$\n",
    "\n",
    "where the added noise is clipped to keep the target close tothe original action."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## import module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "import os\n",
    "import random\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.backends.cudnn.enabled:\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "torch.manual_seed(seed)\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "Typically, people implement replay buffers with one of the following three data structures:\n",
    "\n",
    "- collections.deque\n",
    "- list\n",
    "- numpy.ndarray\n",
    "\n",
    "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of Get item is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
    "\n",
    "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference), . Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
    "\n",
    "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
    "\n",
    "Reference: \n",
    "- [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)\n",
    "- [rainbow-is-all-you-need](https://render.githubusercontent.com/view/ipynb?commit=032d11277cf2436853478a69ca5a4aba03202598&enc_url=68747470733a2f2f7261772e67697468756275736572636f6e74656e742e636f6d2f437572742d5061726b2f7261696e626f772d69732d616c6c2d796f752d6e6565642f303332643131323737636632343336383533343738613639636135613461626130333230323539382f30312e64716e2e6970796e62&nwo=Curt-Park%2Frainbow-is-all-you-need&path=01.dqn.ipynb&repository_id=191133946&repository_type=Repository#Replay-buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray,\n",
    "        rew: float,\n",
    "        next_obs: np.ndarray,\n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(\n",
    "            obs=self.obs_buf[idxs],\n",
    "            next_obs=self.next_obs_buf[idxs],\n",
    "            acts=self.acts_buf[idxs],\n",
    "            rews=self.rews_buf[idxs],\n",
    "            done=self.done_buf[idxs],\n",
    "        )\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gaussian Noise\n",
    "Because the DDPG and the TD3 policy is deterministic, it's not enough to explore a wide variety of actions. In order to facilitate more exploration. TD3 adds Gaussian noise to each action, while DDPG uses Ornstein-Uhlenbeck noise. The TD3 paper states Ornstein-Uhlenbeck noise offered no performance benefits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GaussianNoise:\n",
    "    \"\"\"Gaussian Noise.\n",
    "    Taken from https://github.com/vitchyr/rlkit\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        action_dim: int,\n",
    "        min_sigma: float = 1.0,\n",
    "        max_sigma: float = 1.0,\n",
    "        decay_period: int = 1000000,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        self.action_dim = action_dim\n",
    "        self.max_sigma = max_sigma\n",
    "        self.min_sigma = min_sigma\n",
    "        self.decay_period = decay_period\n",
    "\n",
    "    def sample(self, t: int = 0) -> float:\n",
    "        \"\"\"Get an action with gaussian noise.\"\"\"\n",
    "        sigma = self.max_sigma - (self.max_sigma - self.min_sigma) * min(\n",
    "            1.0, t / self.decay_period\n",
    "        )\n",
    "        return np.random.normal(0, sigma, size=self.action_dim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "We are going to use two separated networks for actor and critic. The actor network has three fully connected layers and three non-linearity functions, *ReLU* for hidden layers and *tanh* for the output layer. On the other hand, the critic network has three fully connected layers, but it used two activation functions for hidden layers *ReLU*. Plus, its input sizes of critic network are sum of state sizes and action sizes. One thing to note is that we initialize the final layer's weights and biases so that they are *uniformly distributed.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int, init_w: float = 3e-3):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Actor, self).__init__()\n",
    "\n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, out_dim)\n",
    "\n",
    "        self.out.weight.data.uniform_(-init_w, init_w)\n",
    "        self.out.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        action = self.out(x).tanh()\n",
    "\n",
    "        return action\n",
    "\n",
    "\n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, in_dim: int, init_w: float = 3e-3):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Critic, self).__init__()\n",
    "\n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, 1)\n",
    "\n",
    "        self.out.weight.data.uniform_(-init_w, init_w)\n",
    "        self.out.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    def forward(self, state: torch.Tensor, action: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = torch.cat((state, action), dim=-1)\n",
    "        x = F.relu(self.hidden1(x))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        value = self.out(x)\n",
    "\n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TD3Agent\n",
    "Here is a summary of TD3Agent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "|---               |---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|\\_target_soft_update| soft update from the local model to the target model.|\n",
    "|\\_plot              | plot the training progresses.                        |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TD3Agent:\n",
    "    \"\"\"TD3Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        actor1 (nn.Module): target actor model to select actions\n",
    "        actor2 (nn.Module): target actor model to select actions\n",
    "        actor_target1 (nn.Module): actor model to predict next actions\n",
    "        actor_target2 (nn.Module): actor model to predict next actions\n",
    "        actor_optimizer (Optimizer): optimizer for training actor\n",
    "        critic1 (nn.Module): critic model to predict state values\n",
    "        critic2 (nn.Module): critic model to predict state values\n",
    "        critic_target1 (nn.Module): target critic model to predict state values\n",
    "        critic_target2 (nn.Module): target critic model to predict state values        \n",
    "        critic_optimizer (Optimizer): optimizer for training critic\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        gamma (float): discount factor\n",
    "        tau (float): parameter for soft target update\n",
    "        initial_random_steps (int): initial random action steps\n",
    "        exploration_noise (GaussianNoise): gaussian noise for policy\n",
    "        target_policy_noise (GaussianNoise): gaussian noise for target policy\n",
    "        target_policy_noise_clip (float): clip target gaussian noise\n",
    "        device (torch.device): cpu / gpu\n",
    "        transition (list): temporory storage for the recent transition\n",
    "        policy_update_freq (int): update actor every time critic updates this times\n",
    "        total_step (int): total step numbers\n",
    "        is_test (bool): flag to show the current mode (train / test)\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        gamma: float = 0.99,\n",
    "        tau: float = 5e-3,\n",
    "        exploration_noise: float = 0.1,\n",
    "        target_policy_noise: float = 0.2,\n",
    "        target_policy_noise_clip: float = 0.5,\n",
    "        initial_random_steps: int = int(1e4),\n",
    "        policy_update_freq: int = 2,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.shape[0]\n",
    "\n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.initial_random_steps = initial_random_steps\n",
    "        self.policy_update_freq = policy_update_freq\n",
    "\n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "        print(self.device)\n",
    "\n",
    "        # noise\n",
    "        self.exploration_noise = GaussianNoise(\n",
    "            action_dim, exploration_noise, exploration_noise\n",
    "        )\n",
    "        self.target_policy_noise = GaussianNoise(\n",
    "            action_dim, target_policy_noise, target_policy_noise\n",
    "        )\n",
    "        self.target_policy_noise_clip = target_policy_noise_clip\n",
    "\n",
    "        # networks\n",
    "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.actor_target = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.actor_target.load_state_dict(self.actor.state_dict())\n",
    "\n",
    "        self.critic1 = Critic(obs_dim + action_dim).to(self.device)\n",
    "        self.critic_target1 = Critic(obs_dim + action_dim).to(self.device)\n",
    "        self.critic_target1.load_state_dict(self.critic1.state_dict())\n",
    "\n",
    "        self.critic2 = Critic(obs_dim + action_dim).to(self.device)\n",
    "        self.critic_target2 = Critic(obs_dim + action_dim).to(self.device)\n",
    "        self.critic_target2.load_state_dict(self.critic2.state_dict())\n",
    "\n",
    "        # concat critic parameters to use one optim\n",
    "        critic_parameters = list(self.critic1.parameters()) + list(\n",
    "            self.critic2.parameters()\n",
    "        )\n",
    "\n",
    "        # optimizer\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=3e-4)\n",
    "        self.critic_optimizer = optim.Adam(critic_parameters, lr=1e-3)\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "\n",
    "        # total steps count\n",
    "        self.total_step = 0\n",
    "\n",
    "        # update step for actor\n",
    "        self.update_step = 0\n",
    "\n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # if initial random action should be conducted\n",
    "        if self.total_step < self.initial_random_steps and not self.is_test:\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = (\n",
    "                self.actor(torch.FloatTensor(state).to(self.device))[0]\n",
    "                .detach()\n",
    "                .cpu()\n",
    "                .numpy()\n",
    "            )\n",
    "\n",
    "        # add noise for exploration during training\n",
    "        if not self.is_test:\n",
    "            noise = self.exploration_noise.sample()\n",
    "            selected_action = np.clip(\n",
    "                selected_action + noise, -1.0, 1.0\n",
    "            )\n",
    "\n",
    "            self.transition = [state, selected_action]\n",
    "\n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "\n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "\n",
    "        samples = self.memory.sample_batch()\n",
    "        states = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_states = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        actions = torch.FloatTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        rewards = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        dones = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        masks = 1 - dones\n",
    "\n",
    "        # get actions with noise\n",
    "        noise = torch.FloatTensor(self.target_policy_noise.sample()).to(device)\n",
    "        clipped_noise = torch.clamp(\n",
    "            noise, -self.target_policy_noise_clip, self.target_policy_noise_clip\n",
    "        )\n",
    "\n",
    "        next_actions = (self.actor_target(next_states) + clipped_noise).clamp(\n",
    "            -1.0, 1.0\n",
    "        )\n",
    "\n",
    "        # min (Q_1', Q_2')\n",
    "        next_values1 = self.critic_target1(next_states, next_actions)\n",
    "        next_values2 = self.critic_target2(next_states, next_actions)\n",
    "        next_values = torch.min(next_values1, next_values2)\n",
    "\n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_returns = rewards + self.gamma * next_values * masks\n",
    "        curr_returns = curr_returns.detach()\n",
    "\n",
    "        # critic loss\n",
    "        values1 = self.critic1(states, actions)\n",
    "        values2 = self.critic2(states, actions)\n",
    "        critic1_loss = F.mse_loss(values1, curr_returns)\n",
    "        critic2_loss = F.mse_loss(values2, curr_returns)\n",
    "\n",
    "        # train critic\n",
    "        critic_loss = critic1_loss + critic2_loss\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "\n",
    "        if self.total_step % self.policy_update_freq == 0:\n",
    "            # train actor\n",
    "            actor_loss = -self.critic1(states, self.actor(states)).mean()\n",
    "\n",
    "            self.actor_optimizer.zero_grad()\n",
    "            actor_loss.backward()\n",
    "            self.actor_optimizer.step()\n",
    "\n",
    "            # target update\n",
    "            self._target_soft_update()\n",
    "        else:\n",
    "            actor_loss = torch.zeros(1)\n",
    "\n",
    "        return actor_loss.data, critic_loss.data\n",
    "\n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "\n",
    "        state = self.env.reset()\n",
    "        actor_losses = []\n",
    "        critic_losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for self.total_step in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if (\n",
    "                len(self.memory) >= self.batch_size\n",
    "                and self.total_step > self.initial_random_steps\n",
    "            ):\n",
    "                actor_loss, critic_loss = self.update_model()\n",
    "                actor_losses.append(actor_loss)\n",
    "                critic_losses.append(critic_loss)\n",
    "\n",
    "            # plotting\n",
    "            if self.total_step % plotting_interval == 0:\n",
    "                self._plot(self.total_step, scores, actor_losses, critic_losses)\n",
    "\n",
    "        self.env.close()\n",
    "\n",
    "    def test(self):\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "\n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "\n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "\n",
    "        return frames\n",
    "\n",
    "    def _target_soft_update(self):\n",
    "        \"\"\"Soft-update: target = tau*local + (1-tau)*target.\"\"\"\n",
    "        tau = self.tau\n",
    "        for t_param, l_param in zip(\n",
    "            self.actor_target.parameters(), self.actor.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "\n",
    "        for t_param, l_param in zip(\n",
    "            self.critic_target1.parameters(), self.critic1.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "\n",
    "        for t_param, l_param in zip(\n",
    "            self.critic_target2.parameters(), self.critic2.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "\n",
    "    def _plot(\n",
    "        self,\n",
    "        frame_idx: int,\n",
    "        scores: List[float],\n",
    "        actor_losses: List[float],\n",
    "        critic_losses: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(30, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title(\"frame %s. score: %s\" % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title(\"actor_loss\")\n",
    "        plt.plot(actor_losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title(\"critic_loss\")\n",
    "        plt.plot(critic_losses)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "*ActionNormalizer* is an action wrapper class to normalize the action values ranged in (-1. 1). Thanks to this class, we can make the agent simply select action values within the zero centered range (-1, 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActionNormalizer(gym.ActionWrapper):\n",
    "    \"\"\"Rescale and relocate the actions.\"\"\"\n",
    "\n",
    "    def action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (-1, 1) to (low, high).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = action * scale_factor + reloc_factor\n",
    "        action = np.clip(action, low, high)\n",
    "\n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (low, high) to (-1, 1).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = (action - reloc_factor) / scale_factor\n",
    "        action = np.clip(action, -1.0, 1.0)\n",
    "\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see [the code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py) and [configurations](https://github.com/openai/gym/blob/cedecb35e3428985fd4efad738befeb75b9077f1/gym/envs/__init__.py#L81) of Pendulum-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# environment\n",
    "env_id = \"Pendulum-v0\"\n",
    "env = gym.make(env_id)\n",
    "env = ActionNormalizer(env)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 50000\n",
    "memory_size = 100000\n",
    "batch_size = 128\n",
    "initial_random_steps = 10000\n",
    "\n",
    "agent = TD3Agent(\n",
    "    env, memory_size, batch_size, initial_random_steps=initial_random_steps\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  -243.10356837973936\n"
     ]
    }
   ],
   "source": [
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgFYMDFMNFTSVSQLWI\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderFYMDFMNFTSVSQLWI\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animFYMDFMNFTSVSQLWI.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animFYMDFMNFTSVSQLWI.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animFYMDFMNFTSVSQLWI.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFYMDFMNFTSVSQLWI.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFYMDFMNFTSVSQLWI.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFYMDFMNFTSVSQLWI.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFYMDFMNFTSVSQLWI.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFYMDFMNFTSVSQLWI.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFYMDFMNFTSVSQLWI.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFYMDFMNFTSVSQLWI.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectFYMDFMNFTSVSQLWI\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgFYMDFMNFTSVSQLWI\";\n",
       "    var slider_id = \"_anim_sliderFYMDFMNFTSVSQLWI\";\n",
       "    var loop_select_id = \"_anim_loop_selectFYMDFMNFTSVSQLWI\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animFYMDFMNFTSVSQLWI = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Imports specifically so we can render outputs in Colab.\n",
    "from matplotlib import animation\n",
    "from JSAnimation.IPython_display import display_animation\n",
    "from IPython.display import display\n",
    "\n",
    "\n",
    "def display_frames_as_gif(frames):\n",
    "    \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "    patch = plt.imshow(frames[0])\n",
    "    plt.axis('off')\n",
    "\n",
    "    def animate(i):\n",
    "        patch.set_data(frames[i])\n",
    "\n",
    "    anim = animation.FuncAnimation(\n",
    "        plt.gcf(), animate, frames = len(frames), interval=50\n",
    "    )\n",
    "    display(display_animation(anim, default_mode='loop'))\n",
    "    \n",
    "        \n",
    "# display \n",
    "display_frames_as_gif(frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
